// api/dialogue.js
// 对话相关的API调用
import { get, post, put, del } from './request';

/**
 * 获取对话列表
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码
 * @param {number} params.pageSize - 每页数量
 * @returns {Promise}
 */
export function getDialogueList(params = { page: 1, pageSize: 20 }) {
  return get('/api/dialogues', params);
}

/**
 * 创建新对话
 * @param {Object} data - 对话信息
 * @param {string} data.title - 对话标题
 * @returns {Promise}
 */
export function createDialogue(data) {
  return post('/api/dialogues', data);
}

/**
 * 获取对话详情
 * @param {string} id - 对话ID
 * @returns {Promise}
 */
export function getDialogueDetail(id) {
  return get(`/api/dialogues/${id}`);
}

/**
 * 更新对话信息
 * @param {string} id - 对话ID
 * @param {Object} data - 更新数据
 * @returns {Promise}
 */
export function updateDialogue(id, data) {
  return put(`/api/dialogues/${id}`, data);
}

/**
 * 删除对话
 * @param {string} id - 对话ID
 * @returns {Promise}
 */
export function deleteDialogue(id) {
  return del(`/api/dialogues/${id}`);
}

/**
 * 获取对话消息
 * @param {string} dialogueId - 对话ID
 * @param {Object} params - 查询参数
 * @returns {Promise}
 */
export function getMessages(dialogueId, params = { page: 1, pageSize: 50 }) {
  return get(`/api/dialogues/${dialogueId}/messages`, params);
}

/**
 * STOMP协议的WebSocket连接管理类
 * 适配后端Spring STOMP WebSocket实现
 */
export class DialogueWebSocket {
  constructor(userId, token, baseUrl = 'ws://10.34.50.158:8080') {
    this.userId = userId;
    this.token = token;
    this.baseUrl = baseUrl;
    this.socket = null;
    this.stompClient = null;
    this.reconnectTimer = null;
    this.reconnectCount = 0;
    this.maxReconnectCount = 5;
    this.listeners = {};
    this.subscriptions = {};
  }

  // 连接WebSocket (STOMP协议)
  connect() {
    return new Promise((resolve, reject) => {
      // 构建STOMP WebSocket连接URL
      const wsUrl = `${this.baseUrl}/ws`;
      
      try {
        // 创建WebSocket连接
        this.socket = uni.connectSocket({
          url: wsUrl,
          header: {
            'Authorization': `Bearer ${this.token}`,
            'userId': this.userId
          },
          success: () => {
            console.log('WebSocket连接初始化成功');
          },
          fail: (err) => {
            console.error('WebSocket连接初始化失败:', err);
            reject(err);
          }
        });

        // WebSocket连接打开后，初始化STOMP客户端
        this.socket.onOpen(() => {
          console.log('WebSocket连接已打开');
          // 模拟STOMP协议握手和订阅
          this.reconnectCount = 0;
          this.emit('open');
          
          // 订阅用户的消息队列
          this.subscribeToUserQueue();
          resolve();
        });

        this.socket.onClose(() => {
          console.log('WebSocket连接已关闭');
          this.emit('close');
          this.handleReconnect();
        });

        this.socket.onError((err) => {
          console.error('WebSocket错误:', err);
          this.emit('error', err);
          reject(err);
        });

        // 处理接收到的消息
        this.socket.onMessage((res) => {
          try {
            // 简单处理接收到的消息
            const data = typeof res.data === 'string' ? JSON.parse(res.data) : res.data;
            this.emit('message', data);
            
            // 根据消息类型触发不同事件
            if (data.message_type) {
              this.emit(data.message_type, data);
            }
          } catch (e) {
            console.error('解析消息失败:', e);
          }
        });
      } catch (e) {
        console.error('WebSocket初始化异常:', e);
        reject(e);
      }
    });
  }

  // 订阅用户队列
  subscribeToUserQueue() {
    // 注册用户队列订阅（实际STOMP客户端会处理这个逻辑）
    this.subscriptions['user-messages'] = true;
    console.log(`已订阅用户[${this.userId}]的消息队列`);
  }

  // 发送聊天消息
  sendChatMessage(data) {
    // 构建符合后端要求的消息格式
    const message = {
      conversation_id: data.conversationId || data.conversation_id || '',
      query: data.query,
      inputs: data.inputs || {},
      files: data.files || [],
      auto_generate_name: data.autoGenerateName || false
    };
    
    // 发送到后端指定的目的地
    this.sendToDestination(`/app/chat/${this.userId}`, message);
  }

  // 发送流式聊天消息
  sendStreamingChatMessage(data) {
    const message = {
      conversation_id: data.conversationId || data.conversation_id || '',
      query: data.query,
      inputs: data.inputs || {},
      files: data.files || [],
      auto_generate_name: data.autoGenerateName || false
    };
    
    this.sendToDestination(`/app/chat/stream/${this.userId}`, message);
  }

  // 发送停止请求
  sendStopRequest(taskId) {
    const message = {
      task_id: taskId
    };
    
    this.sendToDestination(`/app/chat/stop/${this.userId}`, message);
  }

  // 发送消息到指定目的地
  sendToDestination(destination, message) {
    if (this.socket && this.socket.readyState === 1) {
      // 构造STOMP消息格式
      const stompMessage = {
        command: 'SEND',
        headers: {
          'destination': destination,
          'content-type': 'application/json'
        },
        body: JSON.stringify(message)
      };
      
      this.socket.send({
        data: JSON.stringify(stompMessage)
      });
      
      console.log(`已发送消息到目的地: ${destination}`);
    } else {
      console.error('WebSocket未连接，无法发送消息');
    }
  }

  // 关闭连接
  close() {
    if (this.reconnectTimer) {
      clearTimeout(this.reconnectTimer);
      this.reconnectTimer = null;
    }
    if (this.socket) {
      this.socket.close();
      this.socket = null;
    }
    this.stompClient = null;
    this.subscriptions = {};
  }

  // 重连处理
  handleReconnect() {
    if (this.reconnectCount >= this.maxReconnectCount) {
      console.error('WebSocket重连失败，已达到最大重连次数');
      return;
    }

    this.reconnectCount++;
    const delay = Math.min(1000 * Math.pow(2, this.reconnectCount), 30000);
    console.log(`WebSocket将在${delay}ms后进行第${this.reconnectCount}次重连`);

    this.reconnectTimer = setTimeout(() => {
      this.connect().catch(err => {
        console.error('重连失败:', err);
      });
    }, delay);
  }

  // 事件监听
  on(event, callback) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(callback);
  }

  // 移除事件监听
  off(event, callback) {
    if (this.listeners[event]) {
      this.listeners[event] = this.listeners[event].filter(cb => cb !== callback);
    }
  }

  // 触发事件
  emit(event, data) {
    if (this.listeners[event]) {
      this.listeners[event].forEach(callback => {
        try {
          callback(data);
        } catch (e) {
          console.error(`处理${event}事件时出错:`, e);
        }
      });
    }
  }
}